//防抖函数
; (function () {
    return
    let myDebounce = function (fn, wait, immediate) {

        let timer = null, result;
        let outFn = function (...rest) {
            if (timer) clearTimeout(timer);
            // console.log(timer ? '真' : '假')
            if (immediate) {
                if (!timer) {
                    fn.call(this, ...rest)
                }

                timer = setTimeout(() => {
                    timer = null
                }, wait)

            } else {
                timer = setTimeout(() => {
                    timer = null
                    fn.call(this, ...rest)

                }, wait)
            }


        }

        outFn.cancel = function () {
            clearTimeout(timer)
            timer = null

        }
        return outFn
    }
    function debounce(func, wait, immediate) {

        var timeout, result;

        var debounced = function () {
            var context = this;
            var args = arguments;

            if (timeout) clearTimeout(timeout);
            if (immediate) {
                // 如果已经执行过，不再执行
                var callNow = !timeout;
                timeout = setTimeout(function () {
                    timeout = null;
                }, wait)
                if (callNow) result = func.apply(context, args)
            }
            else {
                timeout = setTimeout(function () {
                    result = func.apply(context, args)
                }, wait);
            }
            return result;
        };

        debounced.cancel = function () {
            clearTimeout(timeout);
            timeout = null;
        };

        return debounced;
    }
    class obj3 {
        constructor() {
            this.a = 3
        }
        set = () => {
            console.log(this.a);
        }
    }
    let o = new obj3()
    console.log(o);
    let obj = {
        a: 1,
        set: () => {
            console.log(this.a);
        },
        eat: function () {
            console.log(this.a);
        }
    }
    let obj2 = {
        a: 2,
        set: debounce(o.set, 100, true)
    }
    obj2.set()

})();

//节流函数
; (function () {
    //return
    /**
   * 
   */
    function throttle(func, wait, options) {
        var timeout, context, args, result;
        var previous = 0;
        if (!options) options = {};

        var later = function () {
            previous = options.leading === false ? 0 : new Date().getTime();
            timeout = null;
            func.apply(context, args);
            if (!timeout) context = args = null;
        };

        var throttled = function () {
            var now = new Date().getTime();
            if (!previous && options.leading === false) previous = now;
            var remaining = wait - (now - previous);
            context = this;
            args = arguments;
            if (remaining <= 0 || remaining > wait) {
                if (timeout) {
                    clearTimeout(timeout);
                    timeout = null;
                }
                previous = now;
                func.apply(context, args);
                if (!timeout) context = args = null;
            } else if (!timeout && options.trailing !== false) {
                timeout = setTimeout(later, remaining);
            }
        };

        throttled.cancel = function () {
            clearTimeout(timeout);
            previous = 0;
            timeout = null;
        };

        return throttled;
    }

    var count = 1;


    function getUserAction() {
        count++;
        console.log(count);
    };





})();

